home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1997 May / EnigmA AMIGA RUN 18 (1997)(G.R. Edizioni)(IT)[!][issue 1997-05][EAR-CD II].iso / recent2 / qamitrack1.80.lha / QAmiTrack / source / QAmiTrackShared.c < prev    next >
C/C++ Source or Header  |  1997-04-06  |  8KB  |  275 lines
  1. /* AmiTrackShared.c -- Shared functions between client and server */
  2.  
  3. #define __DICE_C
  4.  
  5. #define __stdargs
  6.  
  7. #include "QAmiTrackShared.h"
  8. #include "TrackRexx.h"
  9.  
  10. #include <devices/timer.h>
  11.  
  12. extern struct Library * IntuitionBase;
  13.  
  14. struct Library * TimerBase = NULL;
  15.  
  16. static ULONG trackFlags = 0L;
  17.  
  18. void TrackExit(char * szMessage, int nCode)
  19. {
  20.     if (nCode > 0) 
  21.     {
  22.       char temp[300];
  23.       
  24.       sprintf(temp, "Exiting, code %i: [%s]",nCode, szMessage);
  25.       printf("%s\n",temp);
  26.       
  27.       if (IntuitionBase) MakeReq("QAmiTrack Exiting Due to Error", temp, "Okay");
  28.     }
  29.     exit(nCode);
  30. }
  31.  
  32. void SetTrackFlag(ULONG flag)
  33. {
  34.   trackFlags |= flag;
  35. }
  36.  
  37. BOOL CheckTrackFlag(ULONG flag)
  38. {
  39.   BOOL ret = ((trackFlags & flag) != 0L);
  40.   trackFlags &= ~flag;
  41.   return(ret);
  42. }
  43.  
  44. BOOL TrackFlagsSet()
  45. {
  46.   return(trackFlags != 0L);
  47. }
  48.  
  49.  
  50. /* Wait for incoming packets or other relevant events */
  51. /* Returns a chord of event codes.  May exit if a CTRL-C is detected. */
  52. void TrackWait(struct WindowStuff * Window, struct QSession * session, struct RexxHost * host, struct CxStuff * cx, struct TimerStuff * ts)
  53. {
  54.     ULONG ulMask = 
  55.         (Window  ? (1L<<Window->win->UserPort->mp_SigBit) : 0L) | 
  56.         (session ? (1L<<session->qMsgPort->mp_SigBit)     : 0L) |
  57.         (host    ? (1L<<host->port->mp_SigBit)            : 0L) |
  58.         (cx      ? (1L<<cx->port->mp_SigBit)              : 0L) |
  59.         (ts      ? (1L<<ts->TimerMP->mp_SigBit)           : 0L) | 
  60.         SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_D | SIGBREAKF_CTRL_E | SIGBREAKF_CTRL_F;
  61.         
  62.     ulMask = Wait(ulMask);
  63.     
  64.     if (ulMask & SIGBREAKF_CTRL_C) SetTrackFlag(CODE_QUIT);
  65.     if (ulMask & SIGBREAKF_CTRL_D) SetTrackFlag(CODE_TIMER);
  66.     if (ulMask & SIGBREAKF_CTRL_E) SetTrackFlag(CODE_HIDE);    
  67.     if (ulMask & SIGBREAKF_CTRL_F) SetTrackFlag(CODE_SHOW);    
  68.     
  69.     if ((ts)&&(ulMask & (1L<<ts->TimerMP->mp_SigBit))) SetTrackFlag(CODE_TIMER); 
  70.     if ((Window)&&(ulMask & (1L<<Window->win->UserPort->mp_SigBit))) SetTrackFlag(CODE_WINDOW_EVENT);
  71.     if ((session)&&(ulMask & (1L<<session->qMsgPort->mp_SigBit))) SetTrackFlag(CODE_QMESSAGE);
  72.     if ((host)&&(ulMask & (1L<<host->port->mp_SigBit))) SetTrackFlag(CODE_AREXX);
  73.     if ((cx)&&(ulMask & (1L << cx->port->mp_SigBit)))
  74.     {
  75.       CxMsg * msg;
  76.       
  77.       while (msg = (CxMsg *) GetMsg(cx->port))
  78.       {
  79.         ULONG msgid   = CxMsgID(msg);
  80.         ULONG msgtype = CxMsgType(msg);
  81.         ReplyMsg((struct Message *) msg);
  82.         
  83.         if (msgtype == CXM_COMMAND)
  84.         {
  85.           switch(msgid)
  86.           {
  87.             case CXCMD_DISABLE:   SetTrackFlag(CODE_DISABLE); break;
  88.             case CXCMD_ENABLE:    SetTrackFlag(CODE_ENABLE);  break;
  89.             case CXCMD_DISAPPEAR: SetTrackFlag(CODE_HIDE);    break;
  90.             case CXCMD_UNIQUE:    /* drop through to... */
  91.             case CXCMD_APPEAR:    SetTrackFlag(CODE_SHOW);    break;
  92.             case CXCMD_KILL:      SetTrackFlag(CODE_QUIT);    break;
  93.           }
  94.         }
  95.         else if (msgtype == CXM_IEVENT)
  96.         {
  97.           switch(msgid)
  98.           {
  99.             case EVT_HOTKEY:      SetTrackFlag(CODE_SHOW);    break;
  100.             default: printf("Warning:  I'm getting unknown CxEvents!\n");
  101.           }
  102.         }
  103.         else printf("warning: I'm getting uncalled for CxMessages!\n");
  104.       }
  105.     }
  106. }
  107.  
  108.  
  109. /* if ts is NULL, allocates and returns all the TimerStuff you need (or NULL on failure) */
  110. /* If ts is non-NULL, frees everything in ts, and returns NULL. */
  111. struct TimerStuff * SetupTimer(struct TimerStuff * ts)
  112. {
  113.     #ifdef __DICE_C
  114.     /* DICE seems to have a bug in it that makes it require this...
  115.        otherwise tv_secs and tv_micro aren't recognized!  :( */
  116.     struct timeval {
  117.         ULONG tv_secs;
  118.         ULONG tv_micro;
  119.     };
  120.     #endif
  121.         
  122.     if (ts)
  123.     {
  124.         /* Deallocate everything! */
  125.         if (ts->TimerIO)
  126.         {
  127.             if (ts->BDevOpen) 
  128.             {
  129.                 if (!(CheckIO((struct IORequest *)ts->TimerIO)))
  130.                     {
  131.                         AbortIO((struct IORequest *)ts->TimerIO);   /* Ask device to abort any pending requests */
  132.                     WaitIO((struct IORequest *)ts->TimerIO);    /* proceed when ready */
  133.                 }
  134.                     CloseDevice((struct IORequest *) ts->TimerIO);
  135.                 }
  136.                 DeleteExtIO((struct IORequest *) ts->TimerIO);
  137.             }
  138.             if (ts->TimerMP) DeletePort(ts->TimerMP);
  139.             FreeMem(ts, sizeof(struct TimerStuff));
  140.             return(NULL);
  141.     }
  142.     else
  143.     {
  144.         /* Set up the timer.device */
  145.         UNLESS(ts = AllocMem(sizeof(struct TimerStuff), MEMF_CLEAR)) return(NULL);
  146.         UNLESS((ts->TimerMP   = CreatePort(0,0))
  147.                 && (ts->TimerIO   = (struct timerequest *) CreateExtIO(ts->TimerMP, (sizeof (struct timerequest))))
  148.                 && (ts->BDevOpen  = (0 == OpenDevice(TIMERNAME,UNIT_VBLANK,(struct IORequest *)ts->TimerIO,0))))
  149.                     return(SetupTimer(ts));
  150.         
  151.         TimerBase = (struct Library *) ts->TimerIO->tr_node.io_Device;
  152.         ts->TimerIO->tr_node.io_Message.mn_ReplyPort = ts->TimerMP;
  153.         ts->TimerIO->tr_node.io_Command  = TR_ADDREQUEST;
  154.         ts->TimerIO->tr_node.io_Flags      = 0;
  155.         ts->TimerIO->tr_node.io_Error      = 0;
  156.         ts->TimerIO->tr_time.tv_secs       = 0;
  157.         ts->TimerIO->tr_time.tv_micro      = 0;     
  158.         return(ts);
  159.     }
  160. }
  161.  
  162.  
  163. int MakeReq(char *sTitle, char *sText, char *sGadgets)
  164. {
  165.     struct EasyStruct myreq;
  166.     int nResult;
  167.  
  168.     UNLESS(sTitle)   sTitle   = "QAmiTrack Message";
  169.     UNLESS(sText)    sText    = "Check this out!";
  170.     UNLESS(sGadgets) sGadgets = "OK";
  171.  
  172.     myreq.es_TextFormat   = sText;
  173.     myreq.es_Title        = sTitle;
  174.     myreq.es_GadgetFormat = sGadgets;
  175.  
  176.     nResult = EasyRequest(NULL, &myreq, NULL, NULL, NULL);
  177.  
  178.     return(nResult);
  179. }
  180.  
  181.  
  182. /* Returns a pointer to the first non-space character in the string */
  183. char * PastSpaces(char * pcString)
  184. {
  185.     while(1) 
  186.     {
  187.         if (*pcString == ' ') pcString++;
  188.                  else return(pcString); 
  189.     }
  190. }
  191.  
  192.  
  193. /* Chops off any trailing blanks and returns the string */
  194. char * RemoveTrailingSpaces(char * pcString)
  195. {
  196.     char * pcTemp = strchr(pcString,'\0');
  197.     
  198.     pcTemp--;
  199.     while((pcTemp > pcString)&&(*pcTemp == ' ')) pcTemp--;
  200.     pcTemp++;
  201.     
  202.     *pcTemp = '\0';
  203.     
  204.     return(pcTemp);
  205. }
  206.  
  207.  
  208. /* Replaces all unprintable characters in pcString with ' ' */
  209. /* Hopefully this will stop people from sending e.g. "talkbombs" */
  210. /* Returns pcString. */
  211. char * RemoveUnprintableChars(char * pcString)
  212. {
  213.     UBYTE * pcTemp = pcString;
  214.     
  215.     while(*pcTemp)
  216.     {
  217.         if (*pcTemp < ' ') *pcTemp = ' ';
  218.         pcTemp++;
  219.     }
  220.     return(pcString);
  221. }
  222.  
  223.  
  224. /* Makes pcString lower case */
  225. char * ToLower(char * pcString)
  226. {
  227.     char * pcTemp = pcString;
  228.     
  229.     while(*pcTemp) 
  230.     {
  231.         if ((*pcTemp >= 'A')&&(*pcTemp <= 'Z'))
  232.             *pcTemp += 'a'-'A';
  233.         pcTemp++;
  234.     }
  235.     return(pcString);
  236. }
  237.  
  238. /* Deallocate the old string, allocate the new string! */
  239. /* Give it a pointer to the pointer to the old string, and a pointer to the new string */
  240. /* Can also server to just deallocate the old, if the new string is NULL */
  241. void ReplaceAllocedString(char ** szOldString, char * szNewString)
  242. {
  243.     char * pcTemp = NULL;
  244.  
  245.     UNLESS(szOldString) return;
  246.     if (szNewString)
  247.     {
  248.         UNLESS(pcTemp = AllocMem(strlen(szNewString)+1, MEMF_ANY)) return;
  249.         strcpy(pcTemp, szNewString);
  250.     }
  251.     if (*szOldString) FreeMem(*szOldString, strlen(*szOldString)+1);
  252.     *szOldString = pcTemp;
  253.     return;
  254. }
  255.  
  256.  
  257. /* Set/Reset timer.device to signal us in nSecs seconds + nMicros microseconds */
  258. void SetTimer(struct TimerStuff * ts, int nSecs, int nMicros)
  259. {
  260.   /* First make sure there is no previous timer pending */
  261.   if (!(CheckIO((struct IORequest *) ts->TimerIO)))
  262.   {
  263.     return;  /* Just ignore new request then */
  264.     /* This way seems bugged! */
  265.     /* AbortIO((struct IORequest *) ts->TimerIO); */
  266.     /* WaitIO((struct IORequest *) ts->TimerIO);  */
  267.   }
  268.                
  269.   ts->TimerIO->tr_time.tv_secs  = nSecs;                                        
  270.   ts->TimerIO->tr_time.tv_micro = nMicros;
  271.         
  272.   /* Start ze timer */
  273.   if ((nSecs > 0)||(nMicros > 0)) SendIO((struct IORequest *)ts->TimerIO);
  274. }
  275.